﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of the data structure required to perform 3D measurements with the sheet-of-light technique.</summary>
	// Token: 0x02000063 RID: 99
	[Serializable]
	public class HSheetOfLightModel : HHandle, ISerializable, ICloneable
	{
		// Token: 0x060017F1 RID: 6129 RVA: 0x0000883B File Offset: 0x00006A3B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HSheetOfLightModel() : base(HHandleBase.UNDEF)
		{
		}

		// Token: 0x060017F2 RID: 6130 RVA: 0x0009A29C File Offset: 0x0009849C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HSheetOfLightModel(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x060017F3 RID: 6131 RVA: 0x0009A2AB File Offset: 0x000984AB
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HSheetOfLightModel(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x060017F4 RID: 6132 RVA: 0x0009A2BA File Offset: 0x000984BA
		private void AssertSemType()
		{
			base.AssertSemType("sheet_of_light_model");
		}

		// Token: 0x060017F5 RID: 6133 RVA: 0x0009A2C7 File Offset: 0x000984C7
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HSheetOfLightModel obj)
		{
			obj = new HSheetOfLightModel(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x060017F6 RID: 6134 RVA: 0x0009A2E0 File Offset: 0x000984E0
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HSheetOfLightModel[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HSheetOfLightModel[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HSheetOfLightModel(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Read a sheet-of-light model from a file and create a new model.
		///   Modified instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="fileName">Name of the sheet-of-light model file. Default: "sheet_of_light_model.solm"</param>
		// Token: 0x060017F7 RID: 6135 RVA: 0x0009A350 File Offset: 0x00098550
		public HSheetOfLightModel(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(374);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a model to perform 3D-measurements using the sheet-of-light technique.
		///   Modified instance represents: Handle for using and accessing the sheet-of-light model.
		/// </summary>
		/// <param name="profileRegion">Region of the images containing the profiles to be processed. If the provided region is not rectangular, its smallest enclosing rectangle will be used.</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the sheet-of-light model. Default: "min_gray"</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the sheet-of-light model. Default: 50</param>
		// Token: 0x060017F8 RID: 6136 RVA: 0x0009A39C File Offset: 0x0009859C
		public HSheetOfLightModel(HRegion profileRegion, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(391);
			HalconAPI.Store(proc, 1, profileRegion);
			HalconAPI.Store(proc, 0, genParamName);
			HalconAPI.Store(proc, 1, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(profileRegion);
		}

		/// <summary>
		///   Create a model to perform 3D-measurements using the sheet-of-light technique.
		///   Modified instance represents: Handle for using and accessing the sheet-of-light model.
		/// </summary>
		/// <param name="profileRegion">Region of the images containing the profiles to be processed. If the provided region is not rectangular, its smallest enclosing rectangle will be used.</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the sheet-of-light model. Default: "min_gray"</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the sheet-of-light model. Default: 50</param>
		// Token: 0x060017F9 RID: 6137 RVA: 0x0009A40C File Offset: 0x0009860C
		public HSheetOfLightModel(HRegion profileRegion, string genParamName, int genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(391);
			HalconAPI.Store(proc, 1, profileRegion);
			HalconAPI.StoreS(proc, 0, genParamName);
			HalconAPI.StoreI(proc, 1, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(profileRegion);
		}

		// Token: 0x060017FA RID: 6138 RVA: 0x0009A470 File Offset: 0x00098670
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeSheetOfLightModel();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x060017FB RID: 6139 RVA: 0x0009A4A8 File Offset: 0x000986A8
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HSheetOfLightModel(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeSheetOfLightModel(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x060017FC RID: 6140 RVA: 0x0009A4E8 File Offset: 0x000986E8
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeSheetOfLightModel();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x060017FD RID: 6141 RVA: 0x0009A4FC File Offset: 0x000986FC
		public new static HSheetOfLightModel Deserialize(Stream stream)
		{
			HSheetOfLightModel hsheetOfLightModel = new HSheetOfLightModel();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hsheetOfLightModel.DeserializeSheetOfLightModel(hserializedItem);
			hserializedItem.Dispose();
			return hsheetOfLightModel;
		}

		// Token: 0x060017FE RID: 6142 RVA: 0x0009A522 File Offset: 0x00098722
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x060017FF RID: 6143 RVA: 0x0009A52C File Offset: 0x0009872C
		public new HSheetOfLightModel Clone()
		{
			HSerializedItem hserializedItem = this.SerializeSheetOfLightModel();
			HSheetOfLightModel hsheetOfLightModel = new HSheetOfLightModel();
			hsheetOfLightModel.DeserializeSheetOfLightModel(hserializedItem);
			hserializedItem.Dispose();
			return hsheetOfLightModel;
		}

		/// <summary>
		///   Read a sheet-of-light model from a file and create a new model.
		///   Modified instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="fileName">Name of the sheet-of-light model file. Default: "sheet_of_light_model.solm"</param>
		// Token: 0x06001800 RID: 6144 RVA: 0x0009A554 File Offset: 0x00098754
		public void ReadSheetOfLightModel(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(374);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write a sheet-of-light model to a file.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="fileName">Name of the sheet-of-light model file. Default: "sheet_of_light_model.solm"</param>
		// Token: 0x06001801 RID: 6145 RVA: 0x0009A5A0 File Offset: 0x000987A0
		public void WriteSheetOfLightModel(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(375);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Deserialize a sheet-of-light model.
		///   Modified instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x06001802 RID: 6146 RVA: 0x0009A5DC File Offset: 0x000987DC
		public void DeserializeSheetOfLightModel(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(376);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize a sheet-of-light model.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x06001803 RID: 6147 RVA: 0x0009A630 File Offset: 0x00098830
		public HSerializedItem SerializeSheetOfLightModel()
		{
			IntPtr proc = HalconAPI.PreCall(377);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calibrate a sheet-of-light setup with a 3D calibration object.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <returns>Average back projection error of the optimization.</returns>
		// Token: 0x06001804 RID: 6148 RVA: 0x0009A678 File Offset: 0x00098878
		public double CalibrateSheetOfLight()
		{
			IntPtr proc = HalconAPI.PreCall(379);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the result of a calibrated measurement performed with the  sheet-of-light technique as a 3D object model.
		///   Instance represents: Handle for accessing the sheet-of-light model.
		/// </summary>
		/// <returns>Handle of the resulting 3D object model.</returns>
		// Token: 0x06001805 RID: 6149 RVA: 0x0009A6C0 File Offset: 0x000988C0
		public HObjectModel3D GetSheetOfLightResultObjectModel3d()
		{
			IntPtr proc = HalconAPI.PreCall(380);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HObjectModel3D result;
			num = HObjectModel3D.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the iconic results of a measurement performed with the sheet-of light technique.
		///   Instance represents: Handle of the sheet-of-light model to be used.
		/// </summary>
		/// <param name="resultName">Specify which result of the measurement shall be provided. Default: "disparity"</param>
		/// <returns>Desired measurement result.</returns>
		// Token: 0x06001806 RID: 6150 RVA: 0x0009A708 File Offset: 0x00098908
		public HImage GetSheetOfLightResult(HTuple resultName)
		{
			IntPtr proc = HalconAPI.PreCall(381);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, resultName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(resultName);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Get the iconic results of a measurement performed with the sheet-of light technique.
		///   Instance represents: Handle of the sheet-of-light model to be used.
		/// </summary>
		/// <param name="resultName">Specify which result of the measurement shall be provided. Default: "disparity"</param>
		/// <returns>Desired measurement result.</returns>
		// Token: 0x06001807 RID: 6151 RVA: 0x0009A760 File Offset: 0x00098960
		public HImage GetSheetOfLightResult(string resultName)
		{
			IntPtr proc = HalconAPI.PreCall(381);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, resultName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply the calibration transformations to the input disparity image.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="disparity">Height or range image to be calibrated.</param>
		// Token: 0x06001808 RID: 6152 RVA: 0x0009A7B0 File Offset: 0x000989B0
		public void ApplySheetOfLightCalibration(HImage disparity)
		{
			IntPtr proc = HalconAPI.PreCall(382);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, disparity);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(disparity);
		}

		/// <summary>
		///   Set sheet of light profiles by measured disparities.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="profileDisparityImage">Disparity image that contains several profiles.</param>
		/// <param name="movementPoses">Poses describing the movement of the scene under measurement between the previously processed profile image and the current profile image.</param>
		// Token: 0x06001809 RID: 6153 RVA: 0x0009A7F4 File Offset: 0x000989F4
		public void SetProfileSheetOfLight(HImage profileDisparityImage, HTuple movementPoses)
		{
			IntPtr proc = HalconAPI.PreCall(383);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, profileDisparityImage);
			HalconAPI.Store(proc, 1, movementPoses);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(movementPoses);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(profileDisparityImage);
		}

		/// <summary>
		///   Process the profile image provided as input and store the resulting disparity to the sheet-of-light model.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="profileImage">Input image.</param>
		/// <param name="movementPose">Pose describing the movement of the scene under measurement between the previously processed profile image and the current profile image.</param>
		// Token: 0x0600180A RID: 6154 RVA: 0x0009A844 File Offset: 0x00098A44
		public void MeasureProfileSheetOfLight(HImage profileImage, HTuple movementPose)
		{
			IntPtr proc = HalconAPI.PreCall(384);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, profileImage);
			HalconAPI.Store(proc, 1, movementPose);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(movementPose);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(profileImage);
		}

		/// <summary>
		///   Set selected parameters of the sheet-of-light model.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="genParamName">Name of the model parameter that shall be adjusted for the sheet-of-light model. Default: "method"</param>
		/// <param name="genParamValue">Value of the model parameter that shall be adjusted for the sheet-of-light model. Default: "center_of_gravity"</param>
		// Token: 0x0600180B RID: 6155 RVA: 0x0009A894 File Offset: 0x00098A94
		public void SetSheetOfLightParam(string genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(385);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set selected parameters of the sheet-of-light model.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="genParamName">Name of the model parameter that shall be adjusted for the sheet-of-light model. Default: "method"</param>
		/// <param name="genParamValue">Value of the model parameter that shall be adjusted for the sheet-of-light model. Default: "center_of_gravity"</param>
		// Token: 0x0600180C RID: 6156 RVA: 0x0009A8E0 File Offset: 0x00098AE0
		public void SetSheetOfLightParam(string genParamName, string genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(385);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.StoreS(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Get the value of a parameter, which has been set in a sheet-of-light model.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="genParamName">Name of the generic parameter that shall be queried. Default: "method"</param>
		/// <returns>Value of the model parameter that shall be queried.</returns>
		// Token: 0x0600180D RID: 6157 RVA: 0x0009A924 File Offset: 0x00098B24
		public HTuple GetSheetOfLightParam(string genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(386);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   For a given sheet-of-light model get the names of the generic iconic or control parameters that can be used in the different sheet-of-light operators.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		/// <param name="queryName">Name of the parameter group. Default: "create_model_params"</param>
		/// <returns>List containing the names of the supported generic parameters.</returns>
		// Token: 0x0600180E RID: 6158 RVA: 0x0009A974 File Offset: 0x00098B74
		public HTuple QuerySheetOfLightParams(string queryName)
		{
			IntPtr proc = HalconAPI.PreCall(387);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, queryName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Reset a sheet-of-light model.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		// Token: 0x0600180F RID: 6159 RVA: 0x0009A9C4 File Offset: 0x00098BC4
		public void ResetSheetOfLightModel()
		{
			IntPtr proc = HalconAPI.PreCall(388);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Delete a sheet-of-light model and free the allocated memory.
		///   Instance represents: Handle of the sheet-of-light model.
		/// </summary>
		// Token: 0x06001810 RID: 6160 RVA: 0x0009A9F8 File Offset: 0x00098BF8
		public void ClearSheetOfLightModel()
		{
			IntPtr proc = HalconAPI.PreCall(390);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create a model to perform 3D-measurements using the sheet-of-light technique.
		///   Modified instance represents: Handle for using and accessing the sheet-of-light model.
		/// </summary>
		/// <param name="profileRegion">Region of the images containing the profiles to be processed. If the provided region is not rectangular, its smallest enclosing rectangle will be used.</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the sheet-of-light model. Default: "min_gray"</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the sheet-of-light model. Default: 50</param>
		// Token: 0x06001811 RID: 6161 RVA: 0x0009AA2C File Offset: 0x00098C2C
		public void CreateSheetOfLightModel(HRegion profileRegion, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(391);
			HalconAPI.Store(proc, 1, profileRegion);
			HalconAPI.Store(proc, 0, genParamName);
			HalconAPI.Store(proc, 1, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(profileRegion);
		}

		/// <summary>
		///   Create a model to perform 3D-measurements using the sheet-of-light technique.
		///   Modified instance represents: Handle for using and accessing the sheet-of-light model.
		/// </summary>
		/// <param name="profileRegion">Region of the images containing the profiles to be processed. If the provided region is not rectangular, its smallest enclosing rectangle will be used.</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the sheet-of-light model. Default: "min_gray"</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the sheet-of-light model. Default: 50</param>
		// Token: 0x06001812 RID: 6162 RVA: 0x0009AA9C File Offset: 0x00098C9C
		public void CreateSheetOfLightModel(HRegion profileRegion, string genParamName, int genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(391);
			HalconAPI.Store(proc, 1, profileRegion);
			HalconAPI.StoreS(proc, 0, genParamName);
			HalconAPI.StoreI(proc, 1, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(profileRegion);
		}
	}
}
